<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>Document</title>
  <style>
    
  </style>
</head>
<body>
  
</body>
<script>

// 3. 有一个全是数值的数组，封装函数，计算总和  reduce
function reduce(origin){
  var sum = 0;
  for(var i=0;i<origin.length;i++){
    sum += origin[i]
  }
  return sum;
}
// var arr = [4,5,6,3,7];
// var res = reduce(arr)
// console.log(res);

// 4. 有一个全是数值的数组，封装函数，计算平均值  avg
function avg(origin){
  var sum = 0;
  for(var i=0;i<origin.length;i++){
    sum += origin[i]
  }
  return sum / origin.length;
}
// var arr = [4,5,6,3,7];
// var res = avg(arr)
// console.log(res);

// 5. 封装函数：从100~999中取出所有的水仙花数，并返回到函数外部
function fn(min, max){
  if(min>max){
    var x = min;
    min = max;
    max = x;
  }
  var arr = [];
  for(var i=min;i<=max;i++){
    var a = parseInt(i/100);
    var b = parseInt(i/10)%10;
    var c = i%10;
    if(a**3 + b**3 + c**3 === i){
      arr.push(i);
    }
  }
  return arr;
}
// console.log(fn(100,999));

// 6. 封装函数：判断一个数组是不是回文数组（对称） 
//   ○ [1,2,3,2,1]
//   ○ [1,2,3,3,2,1]
function isSymmetry(origin){
  // 比较规则：
  // 0 - length-0+1
  // 1 - length-1+1
  // 2 - length-2+1
  // 数组的长度的一半向下取整（不含）
  var n = parseInt(len / 2);
  var len = origin.length;
  for(var i=0;i<n;i++){
    if(origin[i] !== origin[len-(i+1)]){
      return false
    }
  }
  return true;
}
// var arr = [1,2,3,2,1];
// var arr = [1,2,3,3,2,1];
// var arr = [1,2,3,4,2,1];
// var arr = [1,2,3,3,1];
// console.log(isSymmetry(arr));

// 11. 封装函数，根据指定数据，查询数组中是否存在该数据，如果存在，返回出现次数，如果不存在，返回false
//   ○ [3, 4, 5, 6, 5, 4, 6, 5, 3, 2]
//   ○ count(arr, 5);	// 3
//   ○ count(arr, 7);	// false
function includes(origin, data){
  var n = 0;
  // 遍历数组的所有数据
  for(var i=0;i<origin.length;i++){
    // 依次和传入的数据比较
    if(origin[i] === data){
      // 发现重复，记录
      n++
    }
  }
  // 判断是否有记录
  if(n===0){
    // 没有记录，表示没有重复数据，返回false
    return false;
  }else{
    // 有记录，返回记录数
    return n;
  }
}
// var arr = [3, 4, 5, 6, 5, 4, 6, 5, 3, 2]
// console.log(includes( arr, 5 ));
// console.log(includes( arr, 7 ));

// 9. 封装 数组去重的 函数
//   ○ 不允许修改原数组
//   ○ [3, 5, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
//   ○ noRepeat(arr);
//   ○ [3, 5, 2, 4, 6, 1]
// 不允许改变原数组，将去重之后的数据，放在新数组中
// 思路2：先创建一个空的新数组，依次从老数组中取出一个数据，判断新数组中是否存在，如果不存在，那就放在新数组中，如果存在，就继续下一次
function noRepeat(origin){
  // 先创建一个空的新数组
  var arr = [];
  // 依次从老数组中取出一个数据
  for(var i=0;i<origin.length;i++){
    // 判断新数组中是否存在
    if(!arr.includes( origin[i] )){
      // 如果不存在，那就放在新数组中
      arr.push( origin[i] );
    }
  }
  return arr;
}
// var arr = [3, 5, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 1, 1];
// console.log(arr);
// var res = noRepeat(arr);
// console.log(res);
// console.log(arr);
// console.log(arr === res);

// 10. 现有一个排好序的都是数值的数组，插入一个新数据，要求不影响原排序，封装函数实现
//   ○ [1, 3, 4, 6, 9]
//   ○ insert(arr, 5);
//   ○ [1, 3, 4, 5, 6, 9]
function insertSort(origin, data){
  // 方式一：先插入，再排序
  // origin.push(data);
  // origin.sort( function(a,b){return a-b} );

  // 方式二：找到要插入的位置，移动数组中的数据，把位置腾出来，再把新数据设置过去
  // 找到要插入的位置
  for(var i=0;i<origin.length;i++){
    if(origin[i] > data){
      break;
    }
  }
  // 移动数组中的数据，把位置腾出来
  for(var j=origin.length;j>i;j--){
    origin[j] = origin[j-1];
  }
  // 再把新数据设置过去
  origin[i] = data;
}
// var arr = [1, 3, 4, 6, 9];
// console.log(arr);
// insertSort(arr, 5)
// console.log(arr);


  
</script>
</html>